home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / texts / mpindx50.lha / MPIndex50Src.lha / sh / MPIndex.c < prev    next >
C/C++ Source or Header  |  1996-05-13  |  16KB  |  539 lines
  1. // MPIndex - AmigaGuide Indexing program
  2. // Copyright (C) © 1996 Mark John Paddock
  3.  
  4. // This program is free software; you can redistribute it and/or modify
  5. // it under the terms of the GNU General Public License as published by
  6. // the Free Software Foundation; either version 2 of the License, or
  7. // any later version.
  8.  
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. // GNU General Public License for more details.
  13.  
  14. // You should have received a copy of the GNU General Public License
  15. // along with this program; if not, write to the Free Software
  16. // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. // mark@topic.demon.co.uk
  19. // mpaddock@cix.compulink.co.uk
  20.  
  21. // Note this file has been edited!!!
  22.  
  23. /*
  24.  *  Source machine generated by GadToolsBox V2.0
  25.  *  which is (c) Copyright 1991-1993 Jaba Development
  26.  *
  27.  *  GUI Designed by : M J P
  28.  */
  29.  
  30. #include <exec/types.h>
  31. #include <intuition/intuition.h>
  32. #include <intuition/classes.h>
  33. #include <intuition/classusr.h>
  34. #include <intuition/imageclass.h>
  35. #include <intuition/gadgetclass.h>
  36. #include <intuition/sghooks.h>
  37. #include <libraries/gadtools.h>
  38. #include <graphics/displayinfo.h>
  39. #include <graphics/gfxbase.h>
  40. #include <clib/exec_protos.h>
  41. #include <clib/intuition_protos.h>
  42. #include <clib/gadtools_protos.h>
  43. #include <clib/graphics_protos.h>
  44. #include <clib/utility_protos.h>
  45. #include <string.h>
  46. #include <pragmas/exec_pragmas.h>
  47. #include <pragmas/intuition_pragmas.h>
  48. #include <pragmas/gadtools_pragmas.h>
  49. #include <pragmas/graphics_pragmas.h>
  50. #include <pragmas/utility_pragmas.h>
  51. #include <proto/amigaguide.h>
  52.  
  53. #include "MPIndex.h"
  54.  
  55. struct Screen         *Scr = NULL;
  56. UBYTE                 *PubScreenName = NULL;
  57. APTR                   VisualInfo = NULL;
  58. struct Window         *MPIndexWnd = NULL;
  59. struct Gadget         *MPIndexGList = NULL;
  60. struct IntuiMessage    MPIndexMsg;
  61. UWORD                  MPIndexZoom[4];
  62. struct Gadget         *MPIndexGadgets[12];
  63. UWORD                  MPIndexLeft = 38;
  64. UWORD                  MPIndexTop = 13;
  65. UWORD                  MPIndexWidth = 562;
  66. UWORD                  MPIndexHeight = 189;
  67. UBYTE                 *MPIndexWdt = (UBYTE *)"MPIndex";
  68. struct TextAttr       *Font, Attr;
  69. UWORD                  FontX, FontY;
  70. UWORD                  OffX, OffY;
  71. struct Hook                  Hook = {0};
  72. struct HookData           HookData = {0};
  73. struct Hook                  HookNode = {0};
  74. BYTE                          Sig = -1;
  75. BYTE                          SigNode = -1;
  76. struct Hook                  HookList = {0};
  77.  
  78. UWORD MPIndexGTypes[] = {
  79.     STRING_KIND,
  80.     LISTVIEW_KIND,
  81.     LISTVIEW_KIND,
  82.     BUTTON_KIND,
  83.     BUTTON_KIND,
  84.     TEXT_KIND,
  85.     STRING_KIND,
  86.     LISTVIEW_KIND,
  87.     BUTTON_KIND,
  88.     BUTTON_KIND,
  89.     TEXT_KIND,
  90.     TEXT_KIND
  91. };
  92.  
  93. struct NewGadget MPIndexNGad[] = {
  94.     67, 23, 338, 14, (UBYTE *)"_Search", NULL, GD_Search, PLACETEXT_LEFT, NULL, (APTR)SearchClicked,
  95.     5, 51, 400, 64, (UBYTE *)"_Words", NULL, GD_Words, PLACETEXT_ABOVE, NULL, (APTR)WordsClicked,
  96.     5, 142, 400, 48, (UBYTE *)"_Nodes", NULL, GD_Nodes, PLACETEXT_ABOVE, NULL, (APTR)NodesClicked,
  97.     413, 170, 68, 14, (UBYTE *)"S_how", NULL, GD_Show, PLACETEXT_IN, NULL, (APTR)ShowClicked,
  98.     486, 170, 73, 14, (UBYTE *)"_Cancel", NULL, GD_Cancel, PLACETEXT_IN, NULL, (APTR)CancelClicked,
  99.     5, 5, 400, 13, NULL, NULL, GD_Help, 0, NULL, NULL,
  100.     67, 114, 338, 14, (UBYTE *)"S_ubset", NULL, GD_Find, PLACETEXT_LEFT, NULL, (APTR)FindClicked,
  101.     413, 23, 145, 144, NULL, NULL, GD_Guide, 0, NULL, (APTR)GuideClicked,
  102.     413, 5, 68, 13, (UBYTE *)"_All", NULL, GD_All, PLACETEXT_IN, NULL, (APTR)AllClicked,
  103.     486, 5, 73, 13, (UBYTE *)"N_one", NULL, GD_None, PLACETEXT_IN, NULL, (APTR)NoneClicked,
  104.     230, 51, 39, 8, NULL, NULL, GD_WordCount, 0, NULL, NULL,
  105.     230, 142, 39, 8, NULL, NULL, GD_NodeCount, 0, NULL, NULL,
  106. };
  107.  
  108. ULONG MPIndexGTags[] = {
  109.     (GA_TabCycle), TRUE, STRINGA_ExitHelp, TRUE,(GTST_MaxChars), 256, (GT_Underscore), '_', GTST_EditHook, (ULONG)&Hook, (TAG_DONE),
  110.     (GTLV_ShowSelected), NULL, (GT_Underscore), '_', (TAG_DONE),
  111.     (GTLV_ShowSelected), NULL, (GT_Underscore), '_', (TAG_DONE),
  112.     (GT_Underscore), '_', (TAG_DONE),
  113.     (GT_Underscore), '_', (TAG_DONE),
  114.     (GTTX_Border), TRUE, GTTX_Text, (ULONG)"Show help based on Word Index", (TAG_DONE),
  115.     (GA_TabCycle), TRUE, STRINGA_ExitHelp, TRUE, (GTST_MaxChars), 256, (GT_Underscore), '_', GTST_EditHook, (ULONG)&HookNode, (TAG_DONE),
  116.     GTLV_CallBack, (ULONG)&HookList, (TAG_DONE),
  117.     (GT_Underscore), '_', (TAG_DONE),
  118.     (GT_Underscore), '_', (TAG_DONE),
  119.     GTTX_Border, FALSE, (TAG_DONE),
  120.     GTTX_Border, FALSE, (TAG_DONE)
  121. };
  122.  
  123. char *GuideNode = "main";
  124.  
  125. static UWORD ComputeX( UWORD value )
  126. {
  127.     if (FontX < 8) {
  128.         return(( UWORD )((( FontX * value ) + 3 ) / 6 ));
  129.     }
  130.     else {
  131.         return(( UWORD )((( FontX * value ) + 4 ) / 8 ));
  132.     }
  133. }
  134.  
  135. static UWORD ComputeY( UWORD value )
  136. {
  137.     return(( UWORD )((( FontY * value ) + 4 ) / 8 ));
  138. }
  139.  
  140. ULONG __saveds __asm HookEntryList(register __a0 struct Hook *Hook,
  141.                                          register __a2 struct FileName *FileName,
  142.                                          register __a1 struct LVDrawMsg *msg) {
  143.     char buffer[3];
  144.     ULONG len;
  145.     WORD length;
  146.     struct TextExtent textExtent;
  147.     if (msg->lvdm_MethodID != LV_DRAW) {
  148.         return LVCB_UNKNOWN;
  149.     }
  150.     switch(msg->lvdm_State) {
  151.     case LVR_NORMAL:
  152.     case LVR_NORMALDISABLED:
  153.     case LVR_SELECTED:
  154.     case LVR_SELECTEDDISABLED:
  155.         Move(msg->lvdm_RastPort,msg->lvdm_Bounds.MinX,msg->lvdm_Bounds.MinY+msg->lvdm_RastPort->TxBaseline);
  156.         length = TextLength(msg->lvdm_RastPort,"W*",2);
  157.         if (FileName->Current) {
  158.             buffer[1] = '*';
  159.         }
  160.         else {
  161.             buffer[1] = ' ';
  162.         }
  163.         if (FileName->WordSel) {
  164.             buffer[0] = 'W';
  165.         }
  166.         else {
  167.             buffer[0] = ' ';
  168.         }
  169.         buffer[2]=0;
  170.         len = TextFit(msg->lvdm_RastPort,FileName->Node.ln_Name,strlen(FileName->Node.ln_Name),&textExtent,NULL,1,msg->lvdm_Bounds.MaxX-msg->lvdm_Bounds.MinX+1-length,32767);
  171.         if (!FileName->Selected) {
  172.             SetABPenDrMd(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[TEXTPEN],msg->lvdm_DrawInfo->dri_Pens[BACKGROUNDPEN],JAM2);
  173.         }
  174.         else {
  175.             SetABPenDrMd(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[FILLTEXTPEN],msg->lvdm_DrawInfo->dri_Pens[FILLPEN],JAM2);
  176.         }
  177.         Text(msg->lvdm_RastPort,buffer,2);
  178.         if (msg->lvdm_RastPort->cp_x < msg->lvdm_Bounds.MinX+length) {
  179.             if (!FileName->Selected) {
  180.                 SetAPen(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[BACKGROUNDPEN]);
  181.             }
  182.             else {
  183.                 SetAPen(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[FILLPEN]);
  184.             }
  185.             RectFill(msg->lvdm_RastPort,msg->lvdm_RastPort->cp_x,msg->lvdm_Bounds.MinY,msg->lvdm_Bounds.MinX-1+length,msg->lvdm_Bounds.MaxY);
  186.         }
  187.         Move(msg->lvdm_RastPort,msg->lvdm_Bounds.MinX+length,msg->lvdm_Bounds.MinY+msg->lvdm_RastPort->TxBaseline);
  188.         if (!FileName->Selected) {
  189.             SetABPenDrMd(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[TEXTPEN],msg->lvdm_DrawInfo->dri_Pens[BACKGROUNDPEN],JAM2);
  190.         }
  191.         else {
  192.             SetABPenDrMd(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[FILLTEXTPEN],msg->lvdm_DrawInfo->dri_Pens[FILLPEN],JAM2);
  193.         }
  194.         Text(msg->lvdm_RastPort,FileName->Node.ln_Name,len);
  195.         if (!FileName->Selected) {
  196.             SetAPen(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[BACKGROUNDPEN]);
  197.         }
  198.         else {
  199.             SetAPen(msg->lvdm_RastPort,msg->lvdm_DrawInfo->dri_Pens[FILLPEN]);
  200.         }
  201.         RectFill(msg->lvdm_RastPort,msg->lvdm_RastPort->cp_x,msg->lvdm_Bounds.MinY,msg->lvdm_Bounds.MaxX,msg->lvdm_Bounds.MaxY);
  202.         break;
  203.     default:
  204.         break;
  205.     }
  206.     return LVCB_OK;
  207. }
  208.  
  209. ULONG __saveds __asm HookEntry(register __a0 struct Hook *Hook,
  210.                                          register __a2 struct SGWork *sgw,
  211.                                          register __a1 ULONG *msg) {
  212.     if (SGH_KEY == *msg) {
  213.         if (((struct HookData *)Hook->h_Data)->Signal) {
  214.             if (strcmp(sgw->PrevBuffer,sgw->WorkBuffer)) {
  215.                 Signal(((struct HookData *)Hook->h_Data)->Task,((struct HookData *)Hook->h_Data)->Signal);
  216.             }
  217.         }
  218.         return ~0;
  219.     }
  220.     else {
  221.         if (SGH_CLICK == *msg) {
  222.             return ~0;
  223.         }
  224.         else {
  225.             return 0;
  226.         }
  227.     }
  228. }
  229.  
  230. ULONG __saveds __asm HookEntryNode(register __a0 struct Hook *Hook,
  231.                                          register __a2 struct SGWork *sgw,
  232.                                          register __a1 ULONG *msg) {
  233.     if (SGH_KEY == *msg) {
  234.         if (-1 != SigNode) {
  235.             if (strcmp(sgw->PrevBuffer,sgw->WorkBuffer)) {
  236.                 Signal(((struct HookData *)Hook->h_Data)->Task,1L<<SigNode);
  237.             }
  238.         }
  239.         return ~0;
  240.     }
  241.     else {
  242.         if (SGH_CLICK == *msg) {
  243.             return ~0;
  244.         }
  245.         else {
  246.             return 0;
  247.         }
  248.     }
  249. }
  250.  
  251. static void ComputeFont( UWORD width, UWORD height )
  252. {
  253.     Font = &Attr;
  254.     Font->ta_Name = (STRPTR)Scr->RastPort.Font->tf_Message.mn_Node.ln_Name;
  255.     Font->ta_YSize = FontY = Scr->RastPort.Font->tf_YSize;
  256.     FontX = Scr->RastPort.Font->tf_XSize;
  257.  
  258.     OffX = Scr->WBorLeft;
  259.     OffY = Scr->RastPort.TxHeight + Scr->WBorTop + 1;
  260.  
  261.     if ( width && height ) {
  262.         if (( ComputeX( width ) + OffX + Scr->WBorRight ) > Scr->Width )
  263.             goto UseTopaz;
  264.         if (( ComputeY( height ) + OffY + Scr->WBorBottom ) > Scr->Height )
  265.             goto UseTopaz;
  266.     }
  267.     return;
  268.  
  269. UseTopaz:
  270.     Font->ta_Name = (STRPTR)"topaz.font";
  271.     FontX = FontY = Font->ta_YSize = 8;
  272. }
  273.  
  274. int SetupScreen( void )
  275. {
  276.     if ( ! ( Scr = LockPubScreen( PubScreenName )))
  277.         return( 1L );
  278.  
  279.     ComputeFont( 0, 0 );
  280.  
  281.     if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  282.         return( 2L );
  283.  
  284.     return( 0L );
  285. }
  286.  
  287. void CloseDownScreen( void )
  288. {
  289.     if ( VisualInfo ) {
  290.         FreeVisualInfo( VisualInfo );
  291.         VisualInfo = NULL;
  292.     }
  293.  
  294.     if ( Scr        ) {
  295.         UnlockPubScreen( NULL, Scr );
  296.         Scr = NULL;
  297.     }
  298. }
  299. typedef int (FPTR(void));
  300. int HandleMPIndexIDCMP( void )
  301. {
  302.     struct IntuiMessage    *m;
  303.     int            (*func)(void);
  304.     BOOL            running = TRUE;
  305.     char            *message;
  306.  
  307.     while( m = GT_GetIMsg( MPIndexWnd->UserPort )) {
  308.  
  309.         CopyMem(( char * )m, ( char * )&MPIndexMsg, (long)sizeof( struct IntuiMessage ));
  310.  
  311.         GT_ReplyIMsg( m );
  312.  
  313.         switch ( MPIndexMsg.Class ) {
  314.  
  315.             case    IDCMP_REFRESHWINDOW:
  316.                 GT_BeginRefresh( MPIndexWnd );
  317.                 GT_EndRefresh( MPIndexWnd, TRUE );
  318.                 break;
  319.  
  320.             case    IDCMP_CLOSEWINDOW:
  321.                 running = MPIndexCloseWindow();
  322.                 break;
  323.  
  324.             case    IDCMP_VANILLAKEY:
  325.                 running = MPIndexVanillaKey();
  326.                 break;
  327.  
  328.             case    IDCMP_RAWKEY:
  329.                 running = MPIndexRawKey();
  330.                 break;
  331.             case    IDCMP_REQCLEAR:
  332.                 ReqClear();
  333.                 break;
  334.             case    IDCMP_GADGETUP:
  335.             case    IDCMP_GADGETDOWN:
  336.                 func = ( FPTR * )(( struct Gadget * )MPIndexMsg.IAddress )->UserData;
  337.                 running = (*func)();
  338.                 break;
  339.             case    IDCMP_GADGETHELP:
  340.                  if ((MPIndexMsg.IAddress == NULL) ||
  341.                       (MPIndexMsg.IAddress == MPIndexWnd)) {
  342.                      message = "Show help based on Word Index";
  343.                      GuideNode = "main";
  344.                  }
  345.                  else {
  346.                     if (((struct Gadget *)MPIndexMsg.IAddress)->GadgetType & GTYP_SYSGADGET) {
  347.                         switch (((struct Gadget *)MPIndexMsg.IAddress)->GadgetType & GTYP_SYSTYPEMASK) {
  348.                          case GTYP_WDRAGGING:
  349.                             message = "Drag window";
  350.                             GuideNode = "g-drag";
  351.                             break;
  352.                         case GTYP_WUPFRONT:
  353.                             message = "Depth arrange window";
  354.                             GuideNode = "g-depth";
  355.                             break;
  356.                         case GTYP_WDOWNBACK:
  357.                              message = "Zoom window";
  358.                              GuideNode = "g-zoom";
  359.                             break;
  360.                         case GTYP_CLOSE:
  361.                             message = "Close window";
  362.                             GuideNode = "g-close";
  363.                             break;
  364.                         default:
  365.                              message = "Show help based on Word Index";
  366.                              GuideNode = "main";
  367.                              break;
  368.                          }
  369.                      }
  370.                      else {
  371.                         switch (((struct Gadget *)MPIndexMsg.IAddress)->GadgetID) {
  372.                         case GD_Search:
  373.                             message = "Search for a Word";
  374.                             GuideNode = "g-search";
  375.                              break;
  376.                         case GD_Words:
  377.                             message = "List of Words";
  378.                             GuideNode = "g-words";
  379.                              break;
  380.                         case GD_Nodes:
  381.                             message = "Nodes containing Word - Double Click to show";
  382.                             GuideNode = "g-nodes";
  383.                              break;
  384.                         case GD_Show:
  385.                             message = "Show Node";
  386.                             GuideNode = "g-show";
  387.                              break;
  388.                         case GD_Cancel:
  389.                             message = "Close window";
  390.                             GuideNode = "g-cancel";
  391.                              break;
  392.                         case GD_Help:
  393.                             message = "Shows help for gadgets";
  394.                             GuideNode = "g-help";
  395.                              break;
  396.                         case GD_Find:
  397.                             message = "Subselect a Node";
  398.                             GuideNode = "g-subset";
  399.                              break;
  400.                         case GD_All:
  401.                             message = "Select All Guide Files";
  402.                             GuideNode = "g-all";
  403.                              break;
  404.                         case GD_None:
  405.                             message = "Select No Guide Files";
  406.                             GuideNode = "g-none";
  407.                              break;
  408.                         case GD_Guide:
  409.                             message = "Select Guide Files";
  410.                             GuideNode = "g-files";
  411.                              break;
  412.                          case GD_WordCount:
  413.                              message = "Number of Words";
  414.                              GuideNode = "g-wordcount";
  415.                              break;
  416.                          case GD_NodeCount:
  417.                              message = "Number of Nodes";
  418.                              GuideNode = "g-nodecount";
  419.                              break;
  420.                          default:
  421.                              message = "Show help based on Word Index";
  422.                              GuideNode = "main";
  423.                              break;
  424.                         }
  425.                      }
  426.                  }
  427.                  if (message) {
  428.                     GT_SetGadgetAttrs(MPIndexGadgets[GDX_Help],MPIndexWnd,NULL,
  429.                                             GTTX_Text,message,
  430.                                             TAG_END);
  431.                 }
  432.                 break;
  433.         }
  434.     }
  435.     return( running );
  436. }
  437.  
  438. int OpenMPIndexWindow( void )
  439. {
  440.     struct NewGadget    ng;
  441.     struct Gadget    *g;
  442.     UWORD        lc, tc;
  443.     UWORD        wleft = MPIndexLeft, wtop = MPIndexTop, ww, wh;
  444.  
  445.     ComputeFont( MPIndexWidth, MPIndexHeight );
  446.  
  447.     ww = ComputeX( MPIndexWidth );
  448.     wh = ComputeY( MPIndexHeight );
  449.  
  450.     if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;
  451.     if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;
  452.  
  453.     HookData.Task = FindTask(NULL);
  454.     if ((Sig = AllocSignal(-1)) != -1) {
  455.         HookData.Signal = 1L<<Sig;
  456.     }
  457.     SigNode = AllocSignal(-1);
  458.     Hook.h_Entry = (ULONG (*)())HookEntry;
  459.     Hook.h_Data     = (APTR)&HookData;
  460.     HookNode.h_Entry = (ULONG (*)())HookEntryNode;
  461.     HookNode.h_Data     = (APTR)&HookData;
  462.     HookList.h_Entry = (ULONG (*)())HookEntryList;
  463.     HookList.h_Data     = NULL;
  464.  
  465.     if ( ! ( g = CreateContext( &MPIndexGList )))
  466.         return( 1L );
  467.  
  468.     for( lc = 0, tc = 0; lc < MPIndex_CNT; lc++ ) {
  469.  
  470.         CopyMem((char * )&MPIndexNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  471.  
  472.         ng.ng_VisualInfo = VisualInfo;
  473.         ng.ng_TextAttr   = Font;
  474.         ng.ng_LeftEdge   = OffX + ComputeX( ng.ng_LeftEdge );
  475.         ng.ng_TopEdge    = OffY + ComputeY( ng.ng_TopEdge );
  476.         if ((lc == GD_WordCount) || (lc == GD_NodeCount)) {
  477.             ng.ng_TopEdge -= (FontY + 4);
  478.         }
  479.         ng.ng_Width      = ComputeX( ng.ng_Width );
  480.         ng.ng_Height     = ComputeY( ng.ng_Height);
  481.  
  482.         MPIndexGadgets[ lc ] = g = CreateGadgetA((ULONG)MPIndexGTypes[ lc ], g, &ng, ( struct TagItem * )&MPIndexGTags[ tc ] );
  483.  
  484.         while( MPIndexGTags[ tc ] ) tc += 2;
  485.         tc++;
  486.  
  487.         if ( NOT g )
  488.             return( 2L );
  489.     }
  490.  
  491.     MPIndexZoom[0] = (USHORT)~0;
  492.     MPIndexZoom[1] = (USHORT)~0;
  493.     MPIndexZoom[2] = TextLength( &Scr->RastPort, (UBYTE *)MPIndexWdt, strlen((char *)MPIndexWdt )) + 80;
  494.     MPIndexZoom[3] = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  495.  
  496.     if ( ! ( MPIndexWnd = OpenWindowTags( NULL,
  497.                 WA_Left,    wleft,
  498.                 WA_Top,        wtop,
  499.                 WA_Width,    ww + OffX + Scr->WBorRight,
  500.                 WA_Height,    wh + OffY + Scr->WBorBottom,
  501.                 WA_IDCMP,    STRINGIDCMP|LISTVIEWIDCMP|BUTTONIDCMP|TEXTIDCMP|IDCMP_CLOSEWINDOW|IDCMP_RAWKEY|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW|IDCMP_GADGETHELP|IDCMP_REQCLEAR,
  502.                 WA_Flags,    WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  503.                 WA_Gadgets,    MPIndexGList,
  504.                 WA_Title,    MPIndexWdt,
  505.                 WA_ScreenTitle,    "MPIndex 5.0 © 1996 M J Paddock",
  506.                 WA_PubScreen,    Scr,
  507.                 WA_Zoom,    MPIndexZoom,
  508.                 WA_AutoAdjust,    TRUE,
  509.                 WA_PubScreenFallBack,    TRUE,
  510.                 TAG_DONE )))
  511.     return( 4L );
  512.  
  513.     // switch on gadget help
  514.     HelpControl(MPIndexWnd,HC_GADGETHELP);
  515.  
  516.     GT_RefreshWindow( MPIndexWnd, NULL );
  517.  
  518.     return( 0L );
  519. }
  520.  
  521. void CloseMPIndexWindow( void )
  522. {
  523.     if ( MPIndexWnd        ) {
  524.         CloseWindow( MPIndexWnd );
  525.         MPIndexWnd = NULL;
  526.     }
  527.  
  528.     if ( MPIndexGList      ) {
  529.         FreeGadgets( MPIndexGList );
  530.         MPIndexGList = NULL;
  531.     }
  532.     if (Sig != -1) {
  533.         FreeSignal(Sig);
  534.     }
  535.     if (SigNode != -1) {
  536.         FreeSignal(SigNode);
  537.     }
  538. }
  539.